{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 决策树——预测隐形眼睛类型\n",
    "\n",
    "**决策树**\n",
    "\n",
    "优点：计算复杂度不高，输出结果易于理解，对中间值缺失不敏感，可以处理不相关特征数据。\n",
    "\n",
    "缺点：可能会产生过度匹配问题。\n",
    "\n",
    "适用数据类型：数值型和标称型\n",
    "\n",
    "创建分支伪代码：\n",
    "\n",
    "```\n",
    "检测数据集中每个子项是否属于同一分类：\n",
    "\n",
    "    if so return 类标签；\n",
    "    else\n",
    "        寻找划分数据集的最好特征\n",
    "        划分数据集\n",
    "        创建分支节点\n",
    "            for 每个划分的子集\n",
    "                调用函数createBranch并增加返回结果到分支节点中\n",
    "        return 分支结点\n",
    "```\n",
    "**决策树的一般流程**\n",
    "\n",
    "1. 收集数据：anyway\n",
    "2. 准备数据：树构造算法只适用于标称数据，数值型数据需要离散化\n",
    "3. 分析数据：anyway，构造树之后，应该检查图形是否符合预期\n",
    "4. 训练算法：构造树的数据结构\n",
    "5. 测试算法：使用经验树计算错误\n",
    "6. 使用算法：词步骤可以适用于任何监督学习算法，使用决策树可以更好地理解数据的内在含义。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import *\n",
    "def calcShannonEnt(dataSet):\n",
    "    numEntries = len(dataSet)\n",
    "    labelCounts = {}\n",
    "    #1.为所有可能分类创建字典\n",
    "    for featVec in dataSet:\n",
    "        currentLabel = featVec[-1]\n",
    "        if currentLabel not in labelCounts.keys():\n",
    "            labelCounts[currentLabel] = 0\n",
    "        labelCounts[currentLabel] += 1\n",
    "    shannonEnt = 0.0\n",
    "    for key in labelCounts:\n",
    "        prob = float(labelCounts[key]) / numEntries\n",
    "        shannonEnt -= prob * math.log(prob,2)#以2为底对数\n",
    "    return shannonEnt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9709505944546686"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def createDataSet():\n",
    "    dataSet = [[1, 1, 'yes'],\n",
    "               [1, 1, 'yes'],\n",
    "               [1,0,'no'],\n",
    "               [0,1,'no'],\n",
    "               [0,1,'no']]\n",
    "    labels = ['no surfacing', 'flippers']\n",
    "    return dataSet, labels\n",
    "myDat, labels = createDataSet()\n",
    "calcShannonEnt(myDat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.3709505944546687"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#增加类别\n",
    "myDat[0][-1] = 'maybe'\n",
    "calcShannonEnt(myDat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def splitDataSet(dataSet, axis, value):\n",
    "    retDataSet = []\n",
    "    for featVec in dataSet:\n",
    "        if featVec[axis] == value:\n",
    "            reducedFeatVec = featVec[:axis]\n",
    "            reducedFeatVec.extend(featVec[axis+1:])\n",
    "            retDataSet.append(reducedFeatVec)\n",
    "    return retDataSet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 'maybe'], [1, 'yes'], [0, 'no']]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "splitDataSet(myDat,0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 'no'], [1, 'no']]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "splitDataSet(myDat,0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def chooseBestFeatureToSplit(dataSet):\n",
    "    numFeatures = len(dataSet[0])-1\n",
    "    baseEntropy = calcShannonEnt(dataSet)\n",
    "    bestInfoGain, bestFeature = 0.0, -1\n",
    "    for i in range(numFeatures):#先找每个特征的不同只\n",
    "        featList = [example[i] for example in dataSet]\n",
    "        uniqueVals = set(featList)#唯一分类标签\n",
    "        newEntropy = 0.0\n",
    "        for value in uniqueVals:#计算每个特征划分的信息熵\n",
    "            subDataSet = splitDataSet(dataSet, i, value)\n",
    "            prob = len(subDataSet) / float(len(dataSet))\n",
    "            newEntropy += prob*calcShannonEnt(subDataSet)\n",
    "        infoGain = baseEntropy - newEntropy\n",
    "        if infoGain > bestInfoGain:\n",
    "            bestInfoGain = infoGain\n",
    "            bestFeature = i\n",
    "        return bestFeature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myDat, labels = createDataSet()\n",
    "chooseBestFeatureToSplit(myDat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 1, 'yes'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myDat#通过观察可以发现确实取第0特征信息增益最大"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import operator\n",
    "def majorityCnt(classList):\n",
    "    classCount={}\n",
    "    for vote in classList:\n",
    "        if vote not in classCount.keys():classCount[vote] = 0\n",
    "        classCount[vote] += 1\n",
    "    sortedClassCount = sorted(classCount.iteritems(),\n",
    "                             key=lambda item:item[1],reverse=True)\n",
    "    return sortedClassCount[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def createTree(dataSet, labels):\n",
    "    classList = [example[-1] for example in dataSet]\n",
    "    #1.类别完全相同停止继续划分\n",
    "    if classList.count(classList[0]) == len(classList):\n",
    "        return classList[0]\n",
    "    #2.遍历完所有特征则返回出现次数最多的\n",
    "    if len(dataSet[0]) == 1:\n",
    "        return majoritycnt(classList)\n",
    "    #3.得到列表包含的所有属性值\n",
    "    bestFeat = chooseBestFeatureToSplit(dataSet)\n",
    "    bestFeatLabel = labels[bestFeat]\n",
    "    myTree = {bestFeatLabel:{}}\n",
    "    del(labels[bestFeat])\n",
    "    featValues = [example[bestFeat] for example in dataSet] #第几个特征被划分\n",
    "    uniqueVals = set(featValues)\n",
    "    for value in uniqueVals:\n",
    "        subLabels = labels[:] #复制label，因为参数传递的是引用\n",
    "        myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value), subLabels)\n",
    "    return myTree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myData, labels = createDataSet()\n",
    "myTree = createTree(myDat, labels)\n",
    "myTree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "#1.定义文本框和箭头格式\n",
    "decisionNode = dict(boxstyle=\"sawtooth\", fc=\"0.8\")\n",
    "leafNode = dict(boxstyle=\"round\", fc=\"0.8\")\n",
    "arrow_args = dict(arrowstyle=\"<-\")\n",
    "#2.绘制带箭头的注解\n",
    "def plotNode(nodeTxt, centerPt, parentPt, nodeType):\n",
    "    createPlot.ax1.annotate(nodeTxt, xy=parentPt, xycoords='axes fraction', xytext=centerPt,\\\n",
    "                            textcoords='axes fraction', va='center', bbox=nodeType, arrowprops=arrow_args)\n",
    "def createPlot():\n",
    "    fig = plt.figure(1, facecolor='white')\n",
    "    fig.clf()\n",
    "    createPlot.ax1 = plt.subplot(111, frameon=False)\n",
    "    plotNode(U'决策节点', (0.5, 0.1), (0.1, 0.5), decisionNode)\n",
    "    plotNode(U'叶节点', (0.8, 0.1), (0.3, 0.8), leafNode)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from pylab import *\n",
    "mpl.rcParams['font.sans-serif'] = ['SimHei']\n",
    "createPlot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getNumLeafs(myTree): #字典的遍历\n",
    "    numLeafs = 0\n",
    "    firstStr = list(myTree.keys())[0]\n",
    "    secondDict = myTree[firstStr]\n",
    "    for key in secondDict.keys():\n",
    "        # 测试结点数据类型是否为词典\n",
    "        if type(secondDict[key]).__name__=='dict':\n",
    "            numLeafs += getNumLeafs(secondDict[key])\n",
    "        else:\n",
    "            numLeafs += 1\n",
    "    return numLeafs\n",
    "\n",
    "def getTreeDepth(myTree):\n",
    "    maxDepth = 0\n",
    "    firstStr = list(myTree.keys())[0]\n",
    "    secondDict = myTree[firstStr]\n",
    "    for key in secondDict.keys():\n",
    "        # 测试结点数据类型是否为词典\n",
    "        if type(secondDict[key]).__name__=='dict':\n",
    "            thisDepth = 1 + getTreeDepth(secondDict[key])\n",
    "        else:\n",
    "            thisDepth = 1\n",
    "        if thisDepth>maxDepth:maxDepth = thisDepth\n",
    "    return maxDepth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def retrieveTree(i):\n",
    "    listOfTrees = [{'no surfacing': {0: 'no', 1: {'flippers': \\\n",
    "                     {0: 'no', 1: 'yes'}}}},\n",
    "                  {'no surfacing': {0: 'no', 1: {'flippers': \\\n",
    "                     {0: {'head':{0:'no', 1:'yes'}}, 1: 'no'}}}}\n",
    "                  ]\n",
    "    return listOfTrees[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'no surfacing': {0: 'no',\n",
       "  1: {'flippers': {0: {'head': {0: 'no', 1: 'yes'}}, 1: 'no'}}}}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "retrieveTree(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "myTree = retrieveTree(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getNumLeafs(myTree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getTreeDepth(myTree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "#plotTree函数\n",
    "def plotMidText(cntrPt, parentPt, txtString):\n",
    "    xMid = (parentPt[0]-cntrPt[0])/2.0 + cntrPt[0]\n",
    "    yMid = (parentPt[1]-cntrPt[1])/2.0 + cntrPt[1]\n",
    "    createPlot.ax1.text(xMid, yMid, txtString, va=\"center\", ha=\"center\", rotation=30)\n",
    "\n",
    "def plotTree(myTree, parentPt, nodeTxt):#if the first key tells you what feat was split on\n",
    "    numLeafs = getNumLeafs(myTree)  #this determines the x width of this tree\n",
    "    depth = getTreeDepth(myTree)\n",
    "    firstStr = list(myTree.keys())[0]     #the text label for this node should be this\n",
    "    cntrPt = (plotTree.xOff + (1.0 + float(numLeafs))/2.0/plotTree.totalW, plotTree.yOff)\n",
    "    plotMidText(cntrPt, parentPt, nodeTxt)\n",
    "    plotNode(firstStr, cntrPt, parentPt, decisionNode)\n",
    "    secondDict = myTree[firstStr]\n",
    "    plotTree.yOff = plotTree.yOff - 1.0/plotTree.totalD\n",
    "    for key in secondDict.keys():\n",
    "        if type(secondDict[key]).__name__=='dict':#test to see if the nodes are dictonaires, if not they are leaf nodes   \n",
    "            plotTree(secondDict[key],cntrPt,str(key))        #recursion\n",
    "        else:   #it's a leaf node print the leaf node\n",
    "            plotTree.xOff = plotTree.xOff + 1.0/plotTree.totalW\n",
    "            plotNode(secondDict[key], (plotTree.xOff, plotTree.yOff), cntrPt, leafNode)\n",
    "            plotMidText((plotTree.xOff, plotTree.yOff), cntrPt, str(key))\n",
    "    plotTree.yOff = plotTree.yOff + 1.0/plotTree.totalD\n",
    "    plotTree.yOff = plotTree.yOff + 1.0/plotTree.totalD\n",
    "#if you do get a dictonary you know it's a tree, and the first element will be another dict\n",
    "\n",
    "def createPlot(inTree):\n",
    "    fig = plt.figure(1, facecolor='white')\n",
    "    fig.clf()\n",
    "    axprops = dict(xticks=[], yticks=[])\n",
    "    createPlot.ax1 = plt.subplot(111, frameon=False, **axprops)    #no ticks\n",
    "    #createPlot.ax1 = plt.subplot(111, frameon=False) #ticks for demo puropses \n",
    "    plotTree.totalW = float(getNumLeafs(inTree))\n",
    "    plotTree.totalD = float(getTreeDepth(inTree))\n",
    "    plotTree.xOff = -0.5/plotTree.totalW; plotTree.yOff = 1.0;\n",
    "    plotTree(inTree, (0.5,1.0), '')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "createPlot(myTree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 测试算法：使用决策树执行分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def classify(inputTree, featLabels, testVec):\n",
    "    firstStr = list(inputTree.keys())[0]\n",
    "    secondDict = inputTree[firstStr]\n",
    "    featIndex = featLabels.index(firstStr)\n",
    "    for key in secondDict.keys():\n",
    "        if testVec[featIndex] == key:\n",
    "            if type(secondDict[key]).__name__=='dict':\n",
    "                classLabel = classify(secondDict[key], featLabels, testVec)\n",
    "            else:classLabel = secondDict[key]\n",
    "    return classLabel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['no surfacing', 'flippers']"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#测试\n",
    "myDat, labels = createDataSet()\n",
    "labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myTree = retrieveTree(0)\n",
    "myTree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'no'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classify(myTree, labels, [1,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'yes'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classify(myTree, labels, [1,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用算法：决策树的存储"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "def storeTree(inputTree, filename):\n",
    "    with open(filename, 'wb') as fw:\n",
    "        pickle.dump(inputTree,fw)\n",
    "        fw.close()\n",
    "def grabTree(fileName):\n",
    "    with open(fileName, 'rb') as fr:\n",
    "        return pickle.load(fr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "storeTree(myTree, 'classifierStorage.txt')\n",
    "grabTree('classifierStorage.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 示例：使用决策树预测隐形眼镜类型\n",
    "\n",
    "1. 收集数据\n",
    "2. 准备数据\n",
    "3. 分析数据：使用createPlot()函数绘制树形图\n",
    "4. 训练算法：使用createTree()函数\n",
    "5. 测试算法：编写测试函数验证决策树可以正确分类给定的数据实例\n",
    "6. 使用算法：存储树的数据结构，以便下次使用时无需重建树"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'age': {'presbyopic': {'prescript': {'hyper': {'astigmatic': {'no': {'tearRate': {'normal': 'soft',\n",
       "        'reduced': 'no lenses'}},\n",
       "      'yes': 'no lenses'}},\n",
       "    'myope': {'astigmatic': {'no': 'no lenses',\n",
       "      'yes': {'tearRate': {'normal': 'hard', 'reduced': 'no lenses'}}}}}},\n",
       "  'young': {'tearRate': {'hard': 'hard',\n",
       "    'soft': 'soft',\n",
       "    'no lenses': 'no lenses'}},\n",
       "  'pre': {'prescript': {'hyper': {'astigmatic': {'no': {'tearRate': {'normal': 'soft',\n",
       "        'reduced': 'no lenses'}},\n",
       "      'yes': 'no lenses'}},\n",
       "    'myope': {'astigmatic': {'no': {'tearRate': {'normal': 'soft',\n",
       "        'reduced': 'no lenses'}},\n",
       "      'yes': {'tearRate': {'normal': 'hard', 'reduced': 'no lenses'}}}}}}}}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with open('lenses.txt') as fr:\n",
    "    lenses = [inst.strip().split('\\t') for inst in fr.readlines()]\n",
    "    lensesLabels = ['age', 'prescript', 'astigmatic', 'tearRate']\n",
    "    lensesTree = createTree(lenses,lensesLabels)\n",
    "lensesTree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "createPlot(lensesTree)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
